package manong.beans;

import java.util.ArrayList;
import java.util.List;

public class CourseTableQuery {

    protected String orderByClause;
    //用于存储排序条件的字符串。通过 setOrderByClause 方法可以设置排序条件，通过 getOrderByClause 方法可以获取排序条件。
    
    protected boolean distinct;
    //指示查询是否需要去重
    
    protected List<Criteria> oredCriteria;
    //存储查询条件的列表，每个条件都是一个 Criteria 对象。通过 getOredCriteria 方法可以获取条件列表，通过 or 方法可以添加新的条件。
    
    protected Boolean forUpdate = false;
    //用于指示查询是否需要进行更新操作。默认情况下设置为 false
    
    
    public CourseTableQuery() {
        oredCriteria = new ArrayList<Criteria>();
    }
//类的构造函数，初始化了 oredCriteria 列表，通常在创建对象时被调用
    
    
    
    
    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }     
    
    
    public String getOrderByClause() {
        return orderByClause;
    }

    //get和set用于设置和获取排序条件
    
    
    
    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }
    //设置和获取是否需要去重
    
    

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }
//返回一个 List<Criteria> 对象，称为 oredCriteria。
   // oredCriteria 是一个列表，用于存储查询条件的集合。
   // 通常，每个 Criteria 对象表示一个条件，而 oredCriteria 则用于存储多个条件，这些条件之间使用 "OR" 连接。
    //返回 oredCriteria 允许调用者访问已添加的查询条件
    
    
    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }
//向查询条件列表中添加一个新的条件，该条件由传递的 Criteria 对象criteria表示。
    //通过调用 oredCriteria.add(criteria)，将新的条件添加到 oredCriteria 列表中。
   // 通常，多次调用 or(Criteria criteria) 方法可以构建复杂的查询条件，这些条件将使用 "OR" 连接，即查询结果中只需满足其中一个条件即可。
    
    
    
    
    
    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }
    //用于创建一个新的 Criteria 对象并将其添加到查询条件列表中，然后返回该新的 Criteria 对象。---》 让你能够在代码中更方便地构建条件
    
    
    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }
//用于创建一个新的 Criteria 对象，如果查询条件列表 oredCriteria 为空，则会先创建一个 Criteria 对象然后添加到列表中。--》确保至少有一个 Criteria 对象可供使用。
    
    
    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }
//受保护的方法，用于内部创建 Criteria 对象。它通常在 createCriteria 方法中被调用，以确保始终有一个新的 Criteria 对象可用。
    
    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }
//清空查询条件列表 oredCriteria，并将排序条件 orderByClause 和去重条件 distinct 重置为初始状态。通常用于重置查询条件，以便构建新的查询。
    
    
    public void setForUpdate(Boolean forUpdate) {
        this.forUpdate = forUpdate;
    }

    public Boolean isForUpdate() {
        return forUpdate;
    }

    //用于设置和获取是否需要进行更新操作。forUpdate 属性表示是否需要将查询结果用于更新操作。
    
    //61-101  提供一种便捷的方式来构建查询条件，同时还支持设置排序和去重等查询选项。
   // 这种模式通常用于构建动态查询，其中查询条件可以根据不同的条件动态生成，从而实现更灵活的查询功能。
    
    
    
    
    //110  -  150     构建查询条件的具体实现
    protected abstract static class GeneratedCriteria {    //不能直接实例化，但可以被具体的子类扩展。
        protected List<Criterion> criteria;   //受保护的字段，它保存了Criterion对象的列表。这些对象表示单独的查询条件。

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }
//GeneratedCriteria类的构造函数。它通过创建一个新的Criterion对象的ArrayList来初始化criteria列表。
        
        
        public boolean isValid() {
            return criteria.size() > 0;
        }
//检查criteria列表中是否有任何条件。---》 如果列表的大小大于0，返回true，表示有有效的查询条件可用。
        
        
        public List<Criterion> getAllCriteria() {
            return criteria;
        }
//提供了对整个条件列表的访问
        
        
        
        public List<Criterion> getCriteria() {
            return criteria;
        }

        
        
        
        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }
//向criteria列表添加简单的条件，接受一个String条件作为参数，并创建一个具有该条件的新Criterion对象。
        //如果条件为null，则会引发RuntimeException异常。
        
        
        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }
//向criteria列表添加具有指定值和属性的条件。它检查值是否为null，如果是，则抛出RuntimeException异常。
        
        
        
        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }
//向criteria列表添加范围条件，其中value1和value2定义了范围。它还检查value1或value2是否为null，如果其中任何一个为null，则会抛出RuntimeException异常。
        
        
        
        
        
        
        //110  -  150   
//向criteria列表添加范围条件，其中value1和value2定义了范围。它还检查value1或value2是否为null
        //如果其中任何一个为null，则会抛出RuntimeException异常。        
        
        
        
        
        
        
        public Criteria andIdIsNull() {
            addCriterion("id is null");
            return (Criteria) this;
        }
        //添加一个条件，即检查列名为"id"的字段是否为null。
       // 它调用了addCriterion("id is null")方法，将条件字符串"id is null"添加到查询条件中，
      //  并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdIsNotNull() {
            addCriterion("id is not null");
            return (Criteria) this;
        }
    //添加一个条件，即检查列名为"id"的字段是否不为null。
   //它调用了addCriterion("id is not null")方法，将条件字符串"id is not null"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdEqualTo(Integer value) {
            addCriterion("id =", value, "id");
            return (Criteria) this;
        }
      //添加一个条件，即检查列名为"id"的字段是否等于给定的整数值。
      //它调用了addCriterion("id =", value, "id")方法，将条件字符串"id = 值"添加到查询条件中，
      //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("id <>", value, "id");
            return (Criteria) this;
        }
        //用于添加一个条件，即检查列名为"id"的字段是否不等于给定的整数值。
        //它调用了addCriterion("id <>", value, "id")方法，将条件字符串"id <> 值"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("id >", value, "id");
            return (Criteria) this;
        }
//用于添加一个条件，即检查列名为"id"的字段是否大于给定的整数值。
//它调用了addCriterion("id >", value, "id")方法，将条件字符串"id > 值"添加到查询条件中，
//并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("id >=", value, "id");
            return (Criteria) this;
        }
//用于添加一个条件，即检查列名为"id"的字段是否大于或等于给定的整数值。
 // 它调用了addCriterion("id >=", value, "id")方法，将条件字符串"id >= 值"添加到查询条件中，
//并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdLessThan(Integer value) {
            addCriterion("id <", value, "id");
            return (Criteria) this;
        }
//添加一个条件，即检查列名为"id"的字段是否小于给定的整数值。
        //它调用了addCriterion("id <", value, "id")方法，将条件字符串"id < 值"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("id <=", value, "id");
            return (Criteria) this;
        }
       //用于添加一个条件，即检查列名为"id"的字段是否小于或等于给定的整数值。
        //它调用了addCriterion("id <=", value, "id")方法，将条件字符串"id <= 值"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdIn(List<Integer> values) {
            addCriterion("id in", values, "id");
            return (Criteria) this;
        }
//用于添加一个条件，即检查列名为"id"的字段是否在给定的整数值列表中。
        //它调用了addCriterion("id in", values, "id")方法，将条件字符串"id in (值1, 值2, ...)"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        
        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("id not in", values, "id");
            return (Criteria) this;
        }
       // 用于添加一个条件，即检查列名为"id"的字段是否不在给定的整数值列表中。
       // 它调用了addCriterion("id not in", values, "id")方法，将条件字符串"id not in (值1, 值2, ...)"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("id between", value1, value2, "id");
            return (Criteria) this;
        }
        //用于添加一个条件，即检查列名为"id"的字段是否在给定的范围内
//用了addCriterion("id between", value1, value2, "id")方法，
        //将条件字符串"id between 值1 and 值2"添加到查询条件中，并返回当前的Criteria对象，以便进行链式调用。
        
        
        
        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("id not between", value1, value2, "id");
            return (Criteria) this;
        }

        //用于添加一个条件，即检查列名为"id"的字段是否不在给定的范围内。
    //它调用了addCriterion("id not between", value1, value2, "id")方法，将条件字符串"id not between 值1 and 值2"添加到查询条件中，
        //并返回当前的Criteria对象，以便进行链式调用。
        
  //182   -  307    ----》允许根据不同的条件要求来构建SQL查询条件，并且支持链式调用，以便简化条件的组合。      
        
        //链式调用的优势在于它可以使代码更加简洁，因为每个方法的调用都在一行内完成。
        //这也有助于提高代码的可读性，因为每个方法都描述了一个清晰的操作步骤。
        //在函数式编程和某些框架（如jQuery）中，链式调用是一种常见的编程风格。
        
        
        
        
        
        //构建数据库查询条件时使用的
        
        public Criteria andArrIdIsNull() {
            addCriterion("arr_id is null");
            return (Criteria) this;
        }
       //添加一个条件，检查"arr_id"字段是否为null。
        
        
        
        
        public Criteria andArrIdIsNotNull() {
            addCriterion("arr_id is not null");
            return (Criteria) this;
        }
        //添加一个条件，检查"arr_id"字段是否不为null。
        
        
        

        public Criteria andArrIdEqualTo(Integer value) {
            addCriterion("arr_id =", value, "arrId");
            return (Criteria) this;
        }
         //添加一个条件，检查"arr_id"字段是否等于指定的整数值。
        
        
        
        
        
        public Criteria andArrIdNotEqualTo(Integer value) {
            addCriterion("arr_id <>", value, "arrId");
            return (Criteria) this;
        }
         //添加一个条件，检查"arr_id"字段是否不等于指定的整数值。
        
        
        
        
        
        public Criteria andArrIdGreaterThan(Integer value) {
            addCriterion("arr_id >", value, "arrId");
            return (Criteria) this;
        }
         //添加一个条件，检查"arr_id"字段是否大于指定的整数值。
        
        
        
        
        
        public Criteria andArrIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("arr_id >=", value, "arrId");
            return (Criteria) this;
        }
        //添加一个条件，检查"arr_id"字段是否大于或等于指定的整数值。
        
        
        
        
        
        

        public Criteria andArrIdLessThan(Integer value) {
            addCriterion("arr_id <", value, "arrId");
            return (Criteria) this;
        }
         //添加一个条件，检查"arr_id"字段是否小于指定的整数值。
        
        
        
        
        
        public Criteria andArrIdLessThanOrEqualTo(Integer value) {
            addCriterion("arr_id <=", value, "arrId");
            return (Criteria) this;
        }
        //添加一个条件，检查"arr_id"字段是否小于或等于指定的整数值。
        
        
        
        
        

        public Criteria andArrIdIn(List<Integer> values) {
            addCriterion("arr_id in", values, "arrId");
            return (Criteria) this;
        }
        //添加一个条件，检查"arr_id"字段是否   在    指定的整数值列表中。
        
        
        
        
        

        public Criteria andArrIdNotIn(List<Integer> values) {
            addCriterion("arr_id not in", values, "arrId");
            return (Criteria) this;
        }
        // 添加一个条件，检查"arr_id"字段是否   不在   指定的整数值列表中。
        
        
        
        
        

        public Criteria andArrIdBetween(Integer value1, Integer value2) {
            addCriterion("arr_id between", value1, value2, "arrId");
            return (Criteria) this;
        }
      // 添加一个条件，检查"arr_id"字段是否在指定的整数值范围内。
        
        
        
        
        
        
        
        public Criteria andArrIdNotBetween(Integer value1, Integer value2) {
            addCriterion("arr_id not between", value1, value2, "arrId");
            return (Criteria) this;
        }
        //添加一个条件，检查"arr_id"字段是否不在指定的整数值范围内。
        
        
        
        //这些方法的命名和返回类型表明它们是为了构建数据库查询条件而设计的，
        //允许开发人员以一种更加流畅和可读的方式来创建复杂的查询。
        //通常，这些方法会与其他查询构建方法一起使用，以最终生成完整的查询语句。
        
        
        
        
        
        
        
        
        

        public Criteria andCourseIdIsNull() {
            addCriterion("course_id is null");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 course_id IS NULL（即课程 ID 为空的记录）
        
        
        

        public Criteria andCourseIdIsNotNull() {
            addCriterion("course_id is not null");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 course_id IS NOT NULL（即课程 ID 不为空的记录）
        
        
        
        public Criteria andCourseIdEqualTo(Integer value) {
            addCriterion("course_id =", value, "courseId");
            return (Criteria) this;
        }
             //添加了一个条件，用于匹配 course_id = value（即课程 ID 等于特定值的记录）。
        
        

        public Criteria andCourseIdNotEqualTo(Integer value) {
            addCriterion("course_id <>", value, "courseId");
            return (Criteria) this;
        }
       //添加了一个条件，用于匹配 course_id <> value（即课程 ID 不等于特定值的记录）
        
        
        
        
        public Criteria andCourseIdGreaterThan(Integer value) {
            addCriterion("course_id >", value, "courseId");
            return (Criteria) this;
        }
      //添加了一个条件，用于匹配 course_id > value（即课程 ID 大于特定值的记录）
        
        
        
        
        
        public Criteria andCourseIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("course_id >=", value, "courseId");
            return (Criteria) this;
        }
       //添加了一个条件，用于匹配 course_id >= value（即课程 ID 大于或等于特定值的记录）
        
        
        
        
        public Criteria andCourseIdLessThan(Integer value) {
            addCriterion("course_id <", value, "courseId");
            return (Criteria) this;
        }
       //添加了一个条件，用于匹配 course_id < value（即课程 ID 小于特定值的记录）
        
        
        
        
        public Criteria andCourseIdLessThanOrEqualTo(Integer value) {
            addCriterion("course_id <=", value, "courseId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 course_id <= value（即课程 ID 小于或等于特定值的记录）
        

        
        
        public Criteria andCourseIdIn(List<Integer> values) {
            addCriterion("course_id in", values, "courseId");
            return (Criteria) this;
        }
       //添加了一个条件，用于匹配 course_id IN (values)（即课程 ID 包含在指定整数列表中的记录）
        
        
        
        
        public Criteria andCourseIdNotIn(List<Integer> values) {
            addCriterion("course_id not in", values, "courseId");
            return (Criteria) this;
        }
      //添加了一个条件，用于匹配 course_id NOT IN (values)（即课程 ID 不包含在指定整数列表中的记录）
        
        
        
        
        //这些方法通常与 SQL 查询构建器一起使用，以根据用户输入或其他运行时条件创建动态查询。
        //生成的 SQL 子句可以组合在一起，形成完整的 SQL 查询，用于数据库操作。
        
        

        
        
        
        
        
        
        
        public Criteria andCourseIdBetween(Integer value1, Integer value2) {
            addCriterion("course_id between", value1, value2, "courseId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 course_id 在指定范围内的记录，即 course_id 的值在 value1 和 value2 之间。
        
        
        
        
   
        public Criteria andCourseIdNotBetween(Integer value1, Integer value2) {
            addCriterion("course_id not between", value1, value2, "courseId");
            return (Criteria) this;
        }
        //andCourseIdNotBetween(Integer value1, Integer value2): 添加了一个条件，
        //用于匹配 course_id 不在指定范围内的记录，即 course_id 的值不在 value1 和 value2 之间。
        
        
        
        
    
        public Criteria andClassIdIsNull() {
            addCriterion("class_id is null");
            return (Criteria) this;
        }
     //添加了一个条件，用于匹配 class_id IS NULL（即 class_id 为空的记录）。
       
        
        
        
        
        public Criteria andClassIdIsNotNull() {
            addCriterion("class_id is not null");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id IS NOT NULL（即 class_id 不为空的记录）。
        
        
        
        
        
        

        public Criteria andClassIdEqualTo(Integer value) {
            addCriterion("class_id =", value, "classId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id = value（即 class_id 等于特定值的记录）。
        
        
        
        
        

        public Criteria andClassIdNotEqualTo(Integer value) {
            addCriterion("class_id <>", value, "classId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id <> value（即 class_id 不等于特定值的记录）。
        
        
        
        
        

        public Criteria andClassIdGreaterThan(Integer value) {
            addCriterion("class_id >", value, "classId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id > value（即 class_id 大于特定值的记录）。
        
        
        
         

        public Criteria andClassIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("class_id >=", value, "classId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 class_id >= value（即 class_id 大于或等于特定值的记录）。
        
        
        
        
        
        public Criteria andClassIdLessThan(Integer value) {
            addCriterion("class_id <", value, "classId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 class_id < value（即 class_id 小于特定值的记录）。
        
        
        
        
        
        public Criteria andClassIdLessThanOrEqualTo(Integer value) {
            addCriterion("class_id <=", value, "classId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id <= value（即 class_id 小于或等于特定值的记录）。
        
        
        //可以与其他条件一起使用，以构建复杂的 SQL 查询，
        //用于从数据库中检索特定条件的数据。这种模式允许在运行时动态构建查询条件，以满足不同的需求。
     
        
        
        

        
        
        
        
        
        
        
        
        
        

        public Criteria andClassIdIn(List<Integer> values) {
            addCriterion("class_id in", values, "classId");
            return (Criteria) this;
        }
        //添加了一个条件，用于匹配 class_id 在指定值的列表中的记录，即 class_id 的值在 values 列表中。
        
        
        
        
        public Criteria andClassIdNotIn(List<Integer> values) {
            addCriterion("class_id not in", values, "classId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 class_id 不在指定值的列表中的记录，即 class_id 的值不在 values 列表中。
        
        
        
        
        
        public Criteria andClassIdBetween(Integer value1, Integer value2) {
            addCriterion("class_id between", value1, value2, "classId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 class_id 在指定范围内的记录，即 class_id 的值在 value1 和 value2 之间。
        
        
        
        
        public Criteria andClassIdNotBetween(Integer value1, Integer value2) {
            addCriterion("class_id not between", value1, value2, "classId");
            return (Criteria) this;
        }
// 添加了一个条件，用于匹配 class_id 不在指定范围内的记录，即 class_id 的值不在 value1 和 value2 之间。
        
        
        
        
        public Criteria andRoomIdIsNull() {
            addCriterion("room_id is null");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 room_id IS NULL（即 room_id 为空的记录）。
        
        
        
        public Criteria andRoomIdIsNotNull() {
            addCriterion("room_id is not null");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 room_id IS NOT NULL（即 room_id 不为空的记录）。
        
        
        
        public Criteria andRoomIdEqualTo(Integer value) {
            addCriterion("room_id =", value, "roomId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 room_id = value（即 room_id 等于特定值的记录）。
        
        
        
        public Criteria andRoomIdNotEqualTo(Integer value) {
            addCriterion("room_id <>", value, "roomId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 room_id <> value（即 room_id 不等于特定值的记录）。
        
        
        
        
        public Criteria andRoomIdGreaterThan(Integer value) {
            addCriterion("room_id >", value, "roomId");
            return (Criteria) this;
        }
//添加了一个条件，用于匹配 room_id > value（即 room_id 大于特定值的记录）。
        
        
        
        //用于构建复杂的 SQL 查询条件，用于从数据库中检索满足特定条件的数据。
           //这种模式允许在运行时动态构建查询条件，以满足不同的需求。
        
        
        
        
        
        

        
        
        
        public Criteria andRoomIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("room_id >=", value, "roomId");
            return (Criteria) this;
        }
//构建一个条件，要求 room_id 大于或等于指定的整数值 value。
        
        //使用 addCriterion 方法将条件添加到查询中，并指定了条件的名称、比较运算符（">="），以及值和字段的关联关系。
       // 最后，返回当前的 Criteria 对象，以便可以继续链式构建其他条件。
        
        
        public Criteria andRoomIdLessThan(Integer value) {
            addCriterion("room_id <", value, "roomId");
            return (Criteria) this;
        }
//构建一个条件，要求 room_id 小于指定的整数值 value
        
        public Criteria andRoomIdLessThanOrEqualTo(Integer value) {
            addCriterion("room_id <=", value, "roomId");
            return (Criteria) this;
        }
//构建一个条件，要求 room_id 小于或等于指定的整数值 value
        
        public Criteria andRoomIdIn(List<Integer> values) {
            addCriterion("room_id in", values, "roomId");
            return (Criteria) this;
        }
//构建一个条件，要求 room_id 的值在给定的整数值列表 values 中
        
        
        public Criteria andRoomIdNotIn(List<Integer> values) {
            addCriterion("room_id not in", values, "roomId");
            return (Criteria) this;
        }
//用于构建一个条件，要求 room_id 的值不在给定的整数值列表 values 中
        
        
        public Criteria andRoomIdBetween(Integer value1, Integer value2) {
            addCriterion("room_id between", value1, value2, "roomId");
            return (Criteria) this;
        }
//用于构建一个条件，要求 room_id 的值在指定的范围内，即大于等于 value1 且小于等于 value2
        
        
        public Criteria andRoomIdNotBetween(Integer value1, Integer value2) {
            addCriterion("room_id not between", value1, value2, "roomId");
            return (Criteria) this;
        }
//用于构建一个条件，要求 room_id 的值不在指定的范围内，即小于 value1 或大于 value2
        
        
        public Criteria andTecherIdIsNull() {
            addCriterion("techer_id is null");
            return (Criteria) this;
        }

        public Criteria andTecherIdIsNotNull() {
            addCriterion("techer_id is not null");
            return (Criteria) this;
        }

      //  用于构建条件，检查 techer_id 字段是否为NULL   或不为NULL。
        
        
        /*
        
        
        这些方法的链式调用可以构建复杂的查询条件，将多个条件组合在一起以满足特定的查询需求。
        可以使用这些方法来构建一个SQL查询语句，以查找满足多个条件的记录。
        
        
        */
        
        
        
        
        
        
        
        public Criteria andTecherIdEqualTo(Integer value) {
            addCriterion("techer_id =", value, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列是否等于指定的值。
        
        
        public Criteria andTecherIdNotEqualTo(Integer value) {
            addCriterion("techer_id <>", value, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列是否不等于指定的值。
        public Criteria andTecherIdGreaterThan(Integer value) {
            addCriterion("techer_id >", value, "techerId");
            return (Criteria) this;
        }
        //生成一个条件，检查 "techer_id" 列是否大于指定的值。
        

        public Criteria andTecherIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("techer_id >=", value, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列是否大于或等于指定的值。
        
        
        public Criteria andTecherIdLessThan(Integer value) {
            addCriterion("techer_id <", value, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列是否小于指定的值。
        
        
        public Criteria andTecherIdLessThanOrEqualTo(Integer value) {
            addCriterion("techer_id <=", value, "techerId");
            return (Criteria) this;
        }
        //生成一个条件，检查 "techer_id" 列是否小于或等于指定的值。
        
        
        
        public Criteria andTecherIdIn(List<Integer> values) {
            addCriterion("techer_id in", values, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列是否在指定的值列表中。
        public Criteria andTecherIdNotIn(List<Integer> values) {
            addCriterion("techer_id not in", values, "techerId");
            return (Criteria) this;
        }
        // 生成一个条件，检查 "techer_id" 列是否不在指定的值列表中。
        public Criteria andTecherIdBetween(Integer value1, Integer value2) {
            addCriterion("techer_id between", value1, value2, "techerId");
            return (Criteria) this;
        }
        // 生成一个条件，检查 "techer_id" 列的值是否在指定的范围内。
        
        /*
    
        帮助开发者构建数据库查询的条件语句，以便从数据库中检索符合特定条件的记录。
         */        

        
        
        
        
        
        public Criteria andTecherIdNotBetween(Integer value1, Integer value2) {
            addCriterion("techer_id not between", value1, value2, "techerId");
            return (Criteria) this;
        }
//生成一个条件，检查 "techer_id" 列的值是否不在指定的范围内。
        
        
        public Criteria andSemeIdIsNull() {
            addCriterion("seme_id is null");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否为NULL。
        
        
        public Criteria andSemeIdIsNotNull() {
            addCriterion("seme_id is not null");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否不为NULL。
        
        
        public Criteria andSemeIdEqualTo(Integer value) {
            addCriterion("seme_id =", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否等于指定的值。
        
        
        public Criteria andSemeIdNotEqualTo(Integer value) {
            addCriterion("seme_id <>", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否不等于指定的值。
        
        
        public Criteria andSemeIdGreaterThan(Integer value) {
            addCriterion("seme_id >", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否大于指定的值。
        
        
        public Criteria andSemeIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("seme_id >=", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否大于或等于指定的值。
        
        
        public Criteria andSemeIdLessThan(Integer value) {
            addCriterion("seme_id <", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否小于指定的值。
        
        public Criteria andSemeIdLessThanOrEqualTo(Integer value) {
            addCriterion("seme_id <=", value, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列是否小于或等于指定的值。
        
        
        /*
        
        
        构建更复杂的查询条件，可以在查询数据库时筛选出符合特定条件的记录，以满足不同的业务需求。这种查询条件构造器通常用于数据库查询操作，以方便地生成SQL查询语句的一部分。
        
        */
        
        
        
        
        public Criteria andSemeIdIn(List<Integer> values) {
            addCriterion("seme_id in", values, "semeId");
            return (Criteria) this;
        }
       // 生成一个条件，检查 "seme_id" 列的值是否在指定的整数列表中。
        public Criteria andSemeIdNotIn(List<Integer> values) {
            addCriterion("seme_id not in", values, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列的值是否不在指定的整数列表中。
        public Criteria andSemeIdBetween(Integer value1, Integer value2) {
            addCriterion("seme_id between", value1, value2, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列的值是否在指定的范围内。
        public Criteria andSemeIdNotBetween(Integer value1, Integer value2) {
            addCriterion("seme_id not between", value1, value2, "semeId");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_id" 列的值是否不在指定的范围内。 
        public Criteria andSemeNameIsNull() {
            addCriterion("seme_name is null");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_name" 列是否为NULL。
        public Criteria andSemeNameIsNotNull() {
            addCriterion("seme_name is not null");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_name" 列是否不为NULL。
        
        
        public Criteria andSemeNameEqualTo(String value) {
            addCriterion("seme_name =", value, "semeName");
            return (Criteria) this;
        }
//: 生成一个条件，检查 "seme_name" 列的值是否等于指定的字符串。
        public Criteria andSemeNameNotEqualTo(String value) {
            addCriterion("seme_name <>", value, "semeName");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_name" 列的值是否不等于指定的字符串。
        public Criteria andSemeNameGreaterThan(String value) {
            addCriterion("seme_name >", value, "semeName");
            return (Criteria) this;
        }
//生成一个条件，检查 "seme_name" 列的值是否大于指定的字符串。
        
        
        /*
        这些方法允许开发者构建更复杂的查询条件，以满足不同的业务需求，可以用于生成SQL查询语句的一部分，用于筛选出数据库中符合特定条件的记录。
        */
        
        
        
        
        
        public Criteria andSemeNameGreaterThanOrEqualTo(String value) {
            addCriterion("seme_name >=", value, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name >= 值"的条件。
        public Criteria andSemeNameLessThan(String value) {
            addCriterion("seme_name <", value, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name < 值"的条件。
        public Criteria andSemeNameLessThanOrEqualTo(String value) {
            addCriterion("seme_name <=", value, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name <= 值"的条件。
        public Criteria andSemeNameLike(String value) {
            addCriterion("seme_name like", value, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name 包含 值"的条件，通常使用通配符进行模糊查询。
        
        public Criteria andSemeNameNotLike(String value) {
            addCriterion("seme_name not like", value, "semeName");
            return (Criteria) this;
        }
//建一个"seme_name 不包含 值"的条件，通常使用通配符进行模糊查询。
        public Criteria andSemeNameIn(List<String> values) {
            addCriterion("seme_name in", values, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name 在给定值列表中"的条件，通常用于查询多个可能的值。
        public Criteria andSemeNameNotIn(List<String> values) {
            addCriterion("seme_name not in", values, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name 不在给定值列表中"的条件。
        public Criteria andSemeNameBetween(String value1, String value2) {
            addCriterion("seme_name between", value1, value2, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name 在两个值之间"的条件。
        public Criteria andSemeNameNotBetween(String value1, String value2) {
            addCriterion("seme_name not between", value1, value2, "semeName");
            return (Criteria) this;
        }
//构建一个"seme_name 不在两个值之间"的条件。
        
        /*
        
        每个方法都会向查询条件中添加相应的限制条件，然后返回自身以支持方法链式调用，以构建复杂的查询条件。
        这种方法允许程序员轻松地构建各种不同类型的查询条件，以满足他们的需求。
        
        
        */
        
        
        public Criteria andTimeIdIsNull() {
            addCriterion("time_id is null");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否为NULL。
        public Criteria andTimeIdIsNotNull() {
            addCriterion("time_id is not null");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否不为NULL。
        
        public Criteria andTimeIdEqualTo(Integer value) {
            addCriterion("time_id =", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否等于给定的整数值(value)。
        public Criteria andTimeIdNotEqualTo(Integer value) {
            addCriterion("time_id <>", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否不等于给定的整数值(value)。
        public Criteria andTimeIdGreaterThan(Integer value) {
            addCriterion("time_id >", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否大于给定的整数值(value)。
        public Criteria andTimeIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("time_id >=", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否大于或等于给定的整数值(value)。
        public Criteria andTimeIdLessThan(Integer value) {
            addCriterion("time_id <", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否小于给定的整数值(value)。
        public Criteria andTimeIdLessThanOrEqualTo(Integer value) {
            addCriterion("time_id <=", value, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否小于或等于给定的整数值(value)。
        public Criteria andTimeIdIn(List<Integer> values) {
            addCriterion("time_id in", values, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于查询"time_id"字段是否在给定整数值列表(values)中。
        
        
        /*
        
        
        在内部调用 addCriterion 方法，并传递相应的条件语句，然后返回自身（Criteria对象），以支持方法链式调用，
        从而可以构建复杂的查询条件。这种方法能够轻松地构建不同类型的查询条件，以满足数据库查询需求。
        
        */
        
        public Criteria andTimeIdNotIn(List<Integer> values) {
            addCriterion("time_id not in", values, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_id" 是否不在提供的整数值列表中。相应的SQL语句可能是 "time_id not in (value1, value2, ...)"。
        
        public Criteria andTimeIdBetween(Integer value1, Integer value2) {
            addCriterion("time_id between", value1, value2, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_id" 是否在给定的整数值范围内。相应的SQL语句可能是 "time_id between value1 和 value2"。
        
        public Criteria andTimeIdNotBetween(Integer value1, Integer value2) {
            addCriterion("time_id not between", value1, value2, "timeId");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_id" 是否不在给定的整数值范围内。相应的SQL语句可能是 "time_id not between value1 和 value2"。
        
        
        public Criteria andTimeNameIsNull() {
            addCriterion("time_name is null");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否为空（null）。
        public Criteria andTimeNameIsNotNull() {
            addCriterion("time_name is not null");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否不为空（not null）。
        public Criteria andTimeNameEqualTo(String value) {
            addCriterion("time_name =", value, "timeName");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否等于提供的字符串值。
        public Criteria andTimeNameNotEqualTo(String value) {
            addCriterion("time_name <>", value, "timeName");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否不等于提供的字符串值。
        public Criteria andTimeNameGreaterThan(String value) {
            addCriterion("time_name >", value, "timeName");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否大于提供的字符串值。
        public Criteria andTimeNameGreaterThanOrEqualTo(String value) {
            addCriterion("time_name >=", value, "timeName");
            return (Criteria) this;
        }
//构建一个条件，用于检查 "time_name" 是否大于或等于提供的字符串值。
        
        
        
        public Criteria andTimeNameLessThan(String value) {
            addCriterion("time_name <", value, "timeName");
            return (Criteria) this;
        }//创建一个条件，用于检查 "time_name" 是否小于提供的字符串值。

        public Criteria andTimeNameLessThanOrEqualTo(String value) {
            addCriterion("time_name <=", value, "timeName");
            return (Criteria) this;
        }// 创建一个条件，用于检查 "time_name" 是否小于或等于提供的字符串值。

        public Criteria andTimeNameLike(String value) {
            addCriterion("time_name like", value, "timeName");
            return (Criteria) this;
        }//创建一个条件，用于检查 "time_name" 是否与提供的字符串值匹配，这里使用 SQL 中的 "LIKE" 操作。

        public Criteria andTimeNameNotLike(String value) {
            addCriterion("time_name not like", value, "timeName");
            return (Criteria) this;
        }//创建一个条件，用于检查 "time_name" 是否不与提供的字符串值匹配，这里使用 SQL 中的 "NOT LIKE" 操作。

        public Criteria andTimeNameIn(List<String> values) {
            addCriterion("time_name in", values, "timeName");
            return (Criteria) this;
        }//创建一个条件，用于检查 "time_name" 是否在提供的字符串值列表中。

        public Criteria andTimeNameNotIn(List<String> values) {
            addCriterion("time_name not in", values, "timeName");
            return (Criteria) this;
        }//创建一个条件，用于检查 "time_name" 是否不在提供的字符串值列表中。

        public Criteria andTimeNameBetween(String value1, String value2) {
            addCriterion("time_name between", value1, value2, "timeName");
            return (Criteria) this;
        }// 创建一个条件，用于检查 "time_name" 是否在提供的两个字符串值之间。

        public Criteria andTimeNameNotBetween(String value1, String value2) {
            addCriterion("time_name not between", value1, value2, "timeName");
            return (Criteria) this;
        }
//创建一个条件，用于检查 "time_name" 是否不在提供的两个字符串值之间。
        public Criteria andCourseNameIsNull() {
            addCriterion("course_name is null");
            return (Criteria) this;
        }//创建一个条件，用于检查 "course_name" 是否为null（空）。

        /*
        
        用于构建复杂的查询条件，以便在数据库表中检索特定的数据记录。根据方法的调用和传递的参数值，将生成相应的SQL查询条件。
        */
        
        
        
        
        
        public Criteria andCourseNameIsNotNull() {
            addCriterion("course_name is not null");
            return (Criteria) this;
        }
// 创建一个条件，检查“course_name”是否不为null（非空）。
        public Criteria andCourseNameEqualTo(String value) {
            addCriterion("course_name =", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否等于提供的字符串值。
        public Criteria andCourseNameNotEqualTo(String value) {
            addCriterion("course_name <>", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否不等于提供的字符串值。
        public Criteria andCourseNameGreaterThan(String value) {
            addCriterion("course_name >", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否大于提供的字符串值。
        public Criteria andCourseNameGreaterThanOrEqualTo(String value) {
            addCriterion("course_name >=", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否大于或等于提供的字符串值。
        public Criteria andCourseNameLessThan(String value) {
            addCriterion("course_name <", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否小于提供的字符串值。
        public Criteria andCourseNameLessThanOrEqualTo(String value) {
            addCriterion("course_name <=", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否小于或等于提供的字符串值。
        public Criteria andCourseNameLike(String value) {
            addCriterion("course_name like", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，使用SQL的“LIKE”操作进行模式匹配，检查“course_name”是否类似于提供的字符串值。
        public Criteria andCourseNameNotLike(String value) {
            addCriterion("course_name not like", value, "courseName");
            return (Criteria) this;
        }
//创建一个条件，使用SQL的“NOT LIKE”操作进行模式匹配，检查“course_name”是否不类似于提供的字符串值。
        
        /*
        
        
        这些方法允许您构建用于查询数据库中“course_name”字段的各种条件。具体取决于使用的方法和传递的值，将相应生成SQL查询的条件。
        
       
        */
        
        
        
        public Criteria andCourseNameIn(List<String> values) {
            addCriterion("course_name in", values, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否包含在提供的字符串值列表中。
        public Criteria andCourseNameNotIn(List<String> values) {
            addCriterion("course_name not in", values, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否不包含在提供的字符串值列表中。
        public Criteria andCourseNameBetween(String value1, String value2) {
            addCriterion("course_name between", value1, value2, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否在提供的两个字符串值之间。
        public Criteria andCourseNameNotBetween(String value1, String value2) {
            addCriterion("course_name not between", value1, value2, "courseName");
            return (Criteria) this;
        }
//创建一个条件，检查“course_name”是否不在提供的两个字符串值之间。
        public Criteria andClassNameIsNull() {
            addCriterion("class_name is null");
            return (Criteria) this;
        }
// 创建一个条件，检查“class_name”是否为null（空）。
        public Criteria andClassNameIsNotNull() {
            addCriterion("class_name is not null");
            return (Criteria) this;
        }
//创建一个条件，检查“class_name”是否不为null（非空）。
        public Criteria andClassNameEqualTo(String value) {
            addCriterion("class_name =", value, "className");
            return (Criteria) this;
        }
// 创建一个条件，检查“class_name”是否等于提供的字符串值。
        public Criteria andClassNameNotEqualTo(String value) {
            addCriterion("class_name <>", value, "className");
            return (Criteria) this;
        }
//创建一个条件，检查“class_name”是否不等于提供的字符串值。
        public Criteria andClassNameGreaterThan(String value) {
            addCriterion("class_name >", value, "className");
            return (Criteria) this;
        }
        //创建一个条件，检查“class_name”是否大于提供的字符串值。
        /*
        这些方法用于帮助构建数据库查询条件，以便进行针对“course_name”和“class_name”字段的数据检索。根据方法的不同，它们将生成不同的SQL查询条件。
        */
        
        

        public Criteria andClassNameGreaterThanOrEqualTo(String value) {
            addCriterion("class_name >=", value, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameLessThan(String value) {
            addCriterion("class_name <", value, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameLessThanOrEqualTo(String value) {
            addCriterion("class_name <=", value, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameLike(String value) {
            addCriterion("class_name like", value, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameNotLike(String value) {
            addCriterion("class_name not like", value, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameIn(List<String> values) {
            addCriterion("class_name in", values, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameNotIn(List<String> values) {
            addCriterion("class_name not in", values, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameBetween(String value1, String value2) {
            addCriterion("class_name between", value1, value2, "className");
            return (Criteria) this;
        }

        public Criteria andClassNameNotBetween(String value1, String value2) {
            addCriterion("class_name not between", value1, value2, "className");
            return (Criteria) this;
        }

        
        
        
        
        
        
        public Criteria andRoomNameIsNull() {
            addCriterion("room_name is null");
            return (Criteria) this;
        }

        public Criteria andRoomNameIsNotNull() {
            addCriterion("room_name is not null");
            return (Criteria) this;
        }

        public Criteria andRoomNameEqualTo(String value) {
            addCriterion("room_name =", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameNotEqualTo(String value) {
            addCriterion("room_name <>", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameGreaterThan(String value) {
            addCriterion("room_name >", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameGreaterThanOrEqualTo(String value) {
            addCriterion("room_name >=", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameLessThan(String value) {
            addCriterion("room_name <", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameLessThanOrEqualTo(String value) {
            addCriterion("room_name <=", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameLike(String value) {
            addCriterion("room_name like", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameNotLike(String value) {
            addCriterion("room_name not like", value, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameIn(List<String> values) {
            addCriterion("room_name in", values, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameNotIn(List<String> values) {
            addCriterion("room_name not in", values, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameBetween(String value1, String value2) {
            addCriterion("room_name between", value1, value2, "roomName");
            return (Criteria) this;
        }

        public Criteria andRoomNameNotBetween(String value1, String value2) {
            addCriterion("room_name not between", value1, value2, "roomName");
            return (Criteria) this;
        }

        public Criteria andTecherNameIsNull() {
            addCriterion("techer_name is null");
            return (Criteria) this;
        }

        public Criteria andTecherNameIsNotNull() {
            addCriterion("techer_name is not null");
            return (Criteria) this;
        }

        public Criteria andTecherNameEqualTo(String value) {
            addCriterion("techer_name =", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameNotEqualTo(String value) {
            addCriterion("techer_name <>", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameGreaterThan(String value) {
            addCriterion("techer_name >", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameGreaterThanOrEqualTo(String value) {
            addCriterion("techer_name >=", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameLessThan(String value) {
            addCriterion("techer_name <", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameLessThanOrEqualTo(String value) {
            addCriterion("techer_name <=", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameLike(String value) {
            addCriterion("techer_name like", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameNotLike(String value) {
            addCriterion("techer_name not like", value, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameIn(List<String> values) {
            addCriterion("techer_name in", values, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameNotIn(List<String> values) {
            addCriterion("techer_name not in", values, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameBetween(String value1, String value2) {
            addCriterion("techer_name between", value1, value2, "techerName");
            return (Criteria) this;
        }

        public Criteria andTecherNameNotBetween(String value1, String value2) {
            addCriterion("techer_name not between", value1, value2, "techerName");
            return (Criteria) this;
        }

        public Criteria andStatuIsNull() {
            addCriterion("statu is null");
            return (Criteria) this;
        }

        public Criteria andStatuIsNotNull() {
            addCriterion("statu is not null");
            return (Criteria) this;
        }

        public Criteria andStatuEqualTo(Integer value) {
            addCriterion("statu =", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuNotEqualTo(Integer value) {
            addCriterion("statu <>", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuGreaterThan(Integer value) {
            addCriterion("statu >", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuGreaterThanOrEqualTo(Integer value) {
            addCriterion("statu >=", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuLessThan(Integer value) {
            addCriterion("statu <", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuLessThanOrEqualTo(Integer value) {
            addCriterion("statu <=", value, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuIn(List<Integer> values) {
            addCriterion("statu in", values, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuNotIn(List<Integer> values) {
            addCriterion("statu not in", values, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuBetween(Integer value1, Integer value2) {
            addCriterion("statu between", value1, value2, "statu");
            return (Criteria) this;
        }

        public Criteria andStatuNotBetween(Integer value1, Integer value2) {
            addCriterion("statu not between", value1, value2, "statu");
            return (Criteria) this;
        }

        public Criteria andTemporaryIsNull() {
            addCriterion("`temporary` is null");
            return (Criteria) this;
        }

        public Criteria andTemporaryIsNotNull() {
            addCriterion("`temporary` is not null");
            return (Criteria) this;
        }

        public Criteria andTemporaryEqualTo(Integer value) {
            addCriterion("`temporary` =", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryNotEqualTo(Integer value) {
            addCriterion("`temporary` <>", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryGreaterThan(Integer value) {
            addCriterion("`temporary` >", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryGreaterThanOrEqualTo(Integer value) {
            addCriterion("`temporary` >=", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryLessThan(Integer value) {
            addCriterion("`temporary` <", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryLessThanOrEqualTo(Integer value) {
            addCriterion("`temporary` <=", value, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryIn(List<Integer> values) {
            addCriterion("`temporary` in", values, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryNotIn(List<Integer> values) {
            addCriterion("`temporary` not in", values, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryBetween(Integer value1, Integer value2) {
            addCriterion("`temporary` between", value1, value2, "temporary");
            return (Criteria) this;
        }

        public Criteria andTemporaryNotBetween(Integer value1, Integer value2) {
            addCriterion("`temporary` not between", value1, value2, "temporary");
            return (Criteria) this;
        }

        public Criteria andMarkIsNull() {
            addCriterion("mark is null");
            return (Criteria) this;
        }

        public Criteria andMarkIsNotNull() {
            addCriterion("mark is not null");
            return (Criteria) this;
        }

        public Criteria andMarkEqualTo(String value) {
            addCriterion("mark =", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkNotEqualTo(String value) {
            addCriterion("mark <>", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkGreaterThan(String value) {
            addCriterion("mark >", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkGreaterThanOrEqualTo(String value) {
            addCriterion("mark >=", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkLessThan(String value) {
            addCriterion("mark <", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkLessThanOrEqualTo(String value) {
            addCriterion("mark <=", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkLike(String value) {
            addCriterion("mark like", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkNotLike(String value) {
            addCriterion("mark not like", value, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkIn(List<String> values) {
            addCriterion("mark in", values, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkNotIn(List<String> values) {
            addCriterion("mark not in", values, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkBetween(String value1, String value2) {
            addCriterion("mark between", value1, value2, "mark");
            return (Criteria) this;
        }

        public Criteria andMarkNotBetween(String value1, String value2) {
            addCriterion("mark not between", value1, value2, "mark");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }
//是另一个名为GeneratedCriteria的类的扩展。它很可能用于构建SQL查询的条件。
    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        /*
        这个类似乎表示SQL查询中的一个单个条件。每个这个类的实例都包含有关特定条件、值和与条件相关的其他属性的信息。

condition：表示SQL条件的部分。
value：表示与条件关联的值。
secondValue：表示第二个值，可能用于范围条件。
noValue：一个指示条件是否没有值的标志。
singleValue：一个指示条件是否有单个值的标志。
betweenValue：一个指示条件是否涉及值范围的标志。
listValue：一个指示条件是否涉及值列表的标志。
typeHandler：表示类型处理程序，可能用于JDBC类型处理。
这些类及其方法似乎是框架或库的一部分，用于通过提供一组类和方法来表示条件，以在Java中以类型安全的方式以编程方式构建复杂的SQL查询。
这是Java中的对象关系映射（ORM）框架或查询构建器中的常见模式。开发人员可以使用这些类以编程方式构建复杂的SQL查询，从而在类型安全的情况下构建查询。
         */
        
        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}